//
// Created by twetec on 25-7-12.
//

#include "../include/network_prober/probe/probe_task_handler.h"

#include <libcron/Cron.h>
#include <boost/asio/ip/address.hpp>

#include <network_prober/database/memory_db_holder.h>
#include <network_prober/database/file_db_holder.h>
#include <network_prober/rpc/perception_rpc_client.h>

#include "handle_icmp_probe_task.h"
#include "handle_tcp_probe_task.h"
#include "handle_udp_probe_task.h"
#include "handle_http_probe_task.h"
#include "handle_https_probe_task.h"
#include "handle_mysql_probe_task.h"
#include "handle_postgresql_probe_task.h"
#include "handle_sqlserver_probe_task.h"
#include "handle_mongodb_probe_task.h"
#include "handle_redis_probe_task.h"

using namespace std::chrono_literals;

namespace network_prober::probe
{
class HandleProbeTaskCoroutine;
// 当前批次观测任务完成后，将观测结果存入数据库
// 观测任务集
static std::vector<HandleProbeTaskCoroutine> s_probeTaskCoroutines;
// 观测结果集 (一个任务对应一个结果)
static std::vector<database::ProbeTaskResultModel> s_probeTaskResults;

// 加锁，等待观测任务结束
static std::mutex s_probeTaskResultsMutx;
static std::condition_variable s_probeTaskResultsCV;

class Promise;

class HandleProbeTaskCoroutine
{
public:
    using promise_type = Promise;

public:
    HandleProbeTaskCoroutine(std::coroutine_handle<promise_type> coroutine) : coroutineHandle(coroutine)
    {}

    HandleProbeTaskCoroutine(const HandleProbeTaskCoroutine&) = delete;
    void operator=(const HandleProbeTaskCoroutine&) = delete;

    HandleProbeTaskCoroutine(HandleProbeTaskCoroutine&& coroutine) noexcept
        : coroutineHandle(std::exchange(coroutine.coroutineHandle, nullptr))
    {
    }

    HandleProbeTaskCoroutine& operator=(HandleProbeTaskCoroutine&& coroutine) noexcept
    {
        coroutineHandle = std::exchange(coroutine.coroutineHandle, nullptr);
        return *this;
    }

    ~HandleProbeTaskCoroutine()
    {}

public:
    // 协程promise对象控制
    std::coroutine_handle<promise_type> coroutineHandle;
};

class Promise
{
public:
    HandleProbeTaskCoroutine get_return_object()
    {
        return HandleProbeTaskCoroutine(std::coroutine_handle<Promise>::from_promise(*this));
    }

    std::suspend_never initial_suspend() { return {}; } // 协程启动时调用
    // std::suspend_always yield_value() { return {}; }    // 协程函数中有co_yield时调用
    void unhandled_exception() {}   // 协程函数发生异常时调用
    // void return_void() {}    // 协程函数

    void return_value(const database::ProbeTaskResultModel& probeTaskResult)   // 协程函数中有co_return 有值时调用
    {
        // SPDLOG_INFO("目标：{} | 延迟：{}", probeTaskResult.uuid, probeTaskResult.delay);
        std::unique_lock<std::mutex> probeTaskResultsLock(s_probeTaskResultsMutx);
        // 保存结果
        s_probeTaskResults.push_back(probeTaskResult);
        // SPDLOG_INFO("完成一个观测目标后的完成数：{}", s_probeTaskResults.size());
        s_probeTaskResultsCV.notify_one();
    }

    std::suspend_never final_suspend() noexcept { return {}; }  // 协程结束时调用

    // GCC11bug 需补上
    template <typename U>
    U&& await_transform(U&& awaitable) noexcept { return static_cast<U&&>(awaitable);}

private:

};

// HandleProbeTaskCoroutine handleICMPProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleICMPProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleICMPProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleICMPProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
//
// HandleProbeTaskCoroutine handleTCPProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleTCPProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
//
// HandleProbeTaskCoroutine handleTCPProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleTCPProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleUDPProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleUDPProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
//
// HandleProbeTaskCoroutine handleUDPProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleUDPProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleHTTPProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleHTTPProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleHTTPProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleHTTPProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleHTTPSProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleHTTPSProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleHTTPSProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleHTTPSProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleMySQLProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleMySQLProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleMySQLProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleMySQLProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handlePostgreSQLProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandlePostgreSQLProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handlePostgreSQLProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandlePostgreSQLProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleSQLServerProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleSQLServerProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleSQLServerProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleSQLServerProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleMongoDBProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleMongoDBProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleMongoDBProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleMongoDBProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }
//
// HandleProbeTaskCoroutine handleRedisProbeTaskIPv4(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleRedisProbeIPv4Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }

template<class T>
HandleProbeTaskCoroutine handleProbeTask(const database::ProbeTaskModel& probeTask)
{
    // 观测结果
    database::ProbeTaskResultModel probeTaskResult {
        .uuid = probeTask.uuid,
        .delay = -1,
        .packetLossRate = 100,
        .probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count(),
    };

    // 记录观测延迟
    std::array<std::int64_t, 4> probeDelays;

    // 依次进行4次观测
    std::size_t probeTimes = probeDelays.size();
    for (std::size_t i = 0; i < probeTimes; i++) {
        // 观测封装对象
        T awaiter(probeTask);
        // 发起观测
        probeDelays[i] = co_await awaiter;
    }

    // 观测结果
    std::size_t packetLossCount = 0;
    std::int64_t totalDelay = 0;
    for (std::size_t i = 0; i < probeDelays.size(); i++) {
        // 如果丢包，则累加丢包数量
        if (probeDelays[i] < 0) {
            packetLossCount++;
            continue;
        }
        // 如果未丢包，则累加延迟
        totalDelay += probeDelays[i];
    }
    // 延迟
    probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
    // 丢包率
    probeTaskResult.packetLossRate = packetLossCount * 100 / probeDelays.size();
    // 观测时间
    probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();

    // 返回观测延迟
    co_return probeTaskResult;
}

// HandleProbeTaskCoroutine handleRedisProbeTaskIPv6(const database::ProbeTaskModel& probeTask)
// {
//     // 记录观测延迟
//     std::array<std::int64_t, 4> probeDelays;
//
//     // 依次进行4次观测
//     std::size_t probeTimes = probeDelays.size();
//     for (std::size_t i = 0; i < probeTimes; i++) {
//         // 观测封装对象
//         HandleRedisProbeIPv6Awaiter awaiter(probeTask);
//         // 发起观测
//         probeDelays[i] = co_await awaiter;
//     }
//
//     // 观测结果
//     database::ProbeTaskResultModel probeTaskResult;
//
//     // 观测目标设备标识
//     probeTaskResult.uuid = probeTask.uuid;
//     // 观测结果
//     std::size_t packetLossCount = 0;
//     std::int64_t totalDelay = 0;
//     for (std::size_t i = 0; i < probeDelays.size(); i++) {
//         // 如果丢包，则累加丢包数量
//         if (probeDelays[i] < 0) {
//             packetLossCount++;
//             continue;
//         }
//         // 如果未丢包，则累加延迟
//         totalDelay += probeDelays[i];
//     }
//     // 延迟
//     probeTaskResult.delay = (probeDelays.size() - packetLossCount) <= 0? -1 : totalDelay / (probeDelays.size() - packetLossCount);
//     // 丢包率
//     probeTaskResult.packetLossRate = packetLossCount / probeDelays.size() * 100;
//     // 观测时间
//     probeTaskResult.probeTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
//
//     // 返回观测延迟
//     co_return probeTaskResult;
// }

void ProbeTaskHandler::_startTaskDispatch()
{
    // 定时任务控制对象
    libcron::Cron cron;

    // 给定时任务添加一个工作计划 [58 * * * * ?] -> 从右往左读 -> 无效周几 每年 每月 每日 每时 每分 的第58秒 执行
    // 等2个0s周期后，观测任务就开始执行
    cron.add_schedule("PROBE_TASK_DISPATCH", "0 * * * * ?", [&](const libcron::TaskInformation& taskInfo) {
        // 获取到任务延迟执行的时间 如果执行时间比计划时间完5s，表示需要调整计划, 则抛出异常
        if (taskInfo.get_delay() > 5s) {
            // 移除定时任务的所有工作计划
            cron.clear_schedules();
            // 日志异常
            std::stringstream ss;
            ss << "观测任务分发线程延迟时间过长：" << taskInfo.get_delay().count() << "秒";
            SPDLOG_ERROR(ss.str());
            throw std::runtime_error(ss.str());
        }

        // 获取所有需要观测的设备
        std::vector<database::ObservedTargetModel> observedTargets = database::MemoryDBHolder::getInstance().getAllObservedTargets();

        // 如果观测的设备还不存在，则直接返回，等待下一次查看
        if (observedTargets.empty()) return;

        // 观测任务(1个任务1局，60秒，4个回合)
        std::vector<database::ProbeTaskModel> probeTasks;
        probeTasks.reserve(observedTargets.size());

        // 循环遍历每一个观测设备，针对每一个观测设备，制定下一局(60s)的观测任务
        for (auto it = observedTargets.begin(); it != observedTargets.end(); ++it) {
            // 观测任务
            database::ProbeTaskModel probeTask;

            probeTask.uuid = it->uuid;    // 设备标识
            probeTask.interface = it->interface;    // 网口名称
            probeTask.address = it->address;  // ip地址
            probeTask.port = it->port; // 端口
            probeTask.protocol = it->protocol;  // 协议 (1:https 2:ICMP 3:TCP 4:UDP 5:PostGreSQL 6:SQL server 7:MySQL 8:MongoDB 9:Redis)
            probeTask.responseCode = it->responseCode; // 响应码
            probeTask.ignoreTsl = it->ignoreTsl;  // 是否忽略TSL错误
            probeTask.requestMethod = it->requestMethod;    // 请求方法 (GET、POST、PUT、DELETE、HEAD、OPTIONS、PATCH)
            probeTask.requestHeader = it->requestHeader;    // 请求头
            probeTask.requestBody = it->requestBody;  // 请求体
            probeTask.responseChallenge = it->responseChallenge;  // 是否身份验证
            probeTask.userName = it->userName; // 用户名
            probeTask.password = it->password; // 密码
            probeTask.databaseName = it->databaseName; // 数据库名称
            probeTask.queryStatement = it->queryStatement;  // 查询语
            probeTask.matchCondition = it->matchCondition;
            probeTask.keyWords = it->keyWords;

            probeTasks.push_back(std::move(probeTask));
        }

        // 在所有观测设备下一局的观测任务制定完后，全部分发到观测任务表中
        database::MemoryDBHolder::getInstance().batchInsertProbeTasks(probeTasks);
    });

    // 作为定时任务的时钟，进行定时
    while(true) {
        cron.tick(); // 保证至少每秒调用一次，避免错过任何调度
        std::this_thread::sleep_for(500ms); // 等待500ms,再调度一次工作计划
    }
}

void ProbeTaskHandler::_startTaskHandle()
{
    // 不断查看是否存在观测任务，如果存在则执行任务，不存在则继续查看
    while (true) {
        // 获取所有观测任务
        std::vector<database::ProbeTaskModel> probeTasks = database::MemoryDBHolder::getInstance().getAllProbeTasks();

        // 当还不存在观测任务时，暂停一会，再去查
        if (probeTasks.empty()) {
            std::this_thread::sleep_for(3s);
            continue;
        }

        for (auto it = probeTasks.begin(); it != probeTasks.end(); ++it) {
            std::cout << "**: " << *it << std::endl;
        }

        // 观测任务取出后，清空缓存
        database::MemoryDBHolder::getInstance().batchRemoveAllProbeTasks();

        // 存在观测任务时，遍历执行每一个观测任务
        for (auto it = probeTasks.begin(); it != probeTasks.end(); ++it) {
            // 获取网口ip地址对象
            boost::asio::ip::address interfaceIPAddress = boost::asio::ip::make_address(it->interface);

            // ICMP协议
            if (it->protocol == database::ProbeNetProtocol::ICMP) {
                if (interfaceIPAddress.is_v4()) {
                    // 调用协程函数，完成一次任务
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleICMPProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    // 调用协程函数，完成一次任务
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleICMPProbeIPv6Awaiter>(*it));
                }
            }
            // TCP协议
            else if (it->protocol == database::ProbeNetProtocol::TCP) {
                // 获取ip地址对象
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleTCPProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleTCPProbeIPv6Awaiter>(*it));
                }
            }
            // UDP协议
            else if (it->protocol == database::ProbeNetProtocol::UDP) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleUDPProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleUDPProbeIPv6Awaiter>(*it));
                }
            }
            // HTTP协议
            else if (it->protocol == database::ProbeNetProtocol::HTTP) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleHTTPProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleHTTPProbeIPv6Awaiter>(*it));
                }
            }
            // HTTPS协议
            else if (it->protocol == database::ProbeNetProtocol::HTTPS) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleHTTPSProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleHTTPSProbeIPv6Awaiter>(*it));
                }
            }
            // MySQL协议
            else if (it->protocol == database::ProbeNetProtocol::MY_SQL) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleMySQLProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleMySQLProbeIPv6Awaiter>(*it));
                }
            }
            // PostgreSQL协议
            else if (it->protocol == database::ProbeNetProtocol::POST_GRE_SQL) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandlePostgreSQLProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandlePostgreSQLProbeIPv6Awaiter>(*it));
                }
            }
            // SQLServer 协议
            else if (it->protocol == database::ProbeNetProtocol::SQL_SERVER) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleSQLServerProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleSQLServerProbeIPv6Awaiter>(*it));
                }
            }
            // MongoDB 协议
            else if (it->protocol == database::ProbeNetProtocol::MONGO_DB) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleMongoDBProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleMongoDBProbeIPv6Awaiter>(*it));
                }
            }
            // Redis 协议
            else if (it->protocol == database::ProbeNetProtocol::REDIS) {
                if (interfaceIPAddress.is_v4()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleRedisProbeIPv4Awaiter>(*it));
                }
                else if (interfaceIPAddress.is_v6()) {
                    s_probeTaskCoroutines.push_back(handleProbeTask<HandleRedisProbeIPv6Awaiter>(*it));
                }
            }
        }

        // 等待当前批次观测任务完成
        std::unique_lock<std::mutex> probeTaskResultsLock(s_probeTaskResultsMutx);
        s_probeTaskResultsCV.wait_for(probeTaskResultsLock, 45s, [] {
            // SPDLOG_INFO("总任务数：{} | 已完成：{}", s_probeTaskCoroutines.size(), s_probeTaskResults.size());
            return s_probeTaskResults.size() >= s_probeTaskCoroutines.size();
        });

        // 清空协程 任务协程，每个协程执行一个观测设备的一轮任务
        s_probeTaskCoroutines.clear();

        // 当前批次的观测任务完成后，入库保存
        database::FileDBHolder::getInstance().batchInsertProbeTaskResults(s_probeTaskResults);

        SPDLOG_INFO("开始上报本轮观测结果..");
        // 当前批次的观测任务完成后，上报平台（异步）
        rpc::PerceptionRPCClient::getInstance().reportProbeTaskResultsToPerception(s_probeTaskResults);
        SPDLOG_INFO("本轮观测结果上报完成..");

        // 清空缓存的观测任务执行结果
        s_probeTaskResults.clear();
    }
}

void ProbeTaskHandler::start()
{
    // 开始任务分发
    std::jthread taskDispatchThread{&ProbeTaskHandler::_startTaskDispatch, this};
    // 开始任务处理
    std::jthread taskHandle{&ProbeTaskHandler::_startTaskHandle, this};
}

ProbeTaskHandler &ProbeTaskHandler::getInstance()
{
    static ProbeTaskHandler instance;
    return instance;
}

ProbeTaskHandler::ProbeTaskHandler()
{
    s_probeTaskResults.reserve(50000);
    s_probeTaskCoroutines.reserve(50000);
}

ProbeTaskHandler::~ProbeTaskHandler()
{
}
}
